package com.code.annotation_compiler;

import com.code.annotations.BindView;
import com.google.auto.service.AutoService;
import java.io.Writer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Filer;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.Processor;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.type.TypeMirror;
import javax.tools.JavaFileObject;

//@AutoService注解:作用是用来生成META-INF/services/javax.annotation.processing.Processor文件
@AutoService(Processor.class)
public class AnnotationsCompiler extends AbstractProcessor {

    //这个方法非常简单，只有一个返回值，用来指定当前正在使用的Java版本，通常return SourceVersion.latestSupported()即可。
    //1.支持的版本
    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.latestSupported();
    }

    //这个方法的返回值是一个Set集合，集合中指要处理的注解类型的名称(这里必须是完整的包名+类名，例如com.example.annotation.BindView)。由于在本例中只需要处理@BindView注解，因此Set集合中只需要添加@BindView的名称即可。
    //2.能用来处理哪些注解
    @Override
    public Set<String> getSupportedAnnotationTypes() {
        Set<String> types = new HashSet<>();
        types.add(BindView.class.getCanonicalName());
        return types;
    }

    //3.定义一个用来生成APT目录下面的文件的对象
    Filer filer;

    //这个方法用于初始化处理器，方法中有一个ProcessingEnvironment类型的参数，ProcessingEnvironment是一个注解处理工具的集合。它包含了众多工具类。
    //例如：
    //Filer可以用来编写新文件；
    //Messager可以用来打印错误信息；
    //Elements是一个可以处理Element的工具类。
        //这个需要了解一下，具体请参考上方博客链接，写得非常好
        //重点：不同类型Element其实就是映射了Java中不同的类元素
    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);
        filer = processingEnvironment.getFiler();
    }

    //4.最重要的一个方法
    //在这个方法的方法体中，我们可以校验被注解的对象是否合法、可以编写处理注解的代码，以及自动生成需要的java文件等
    //我们要处理的大部分逻辑都是在这个方法中完成
    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {

        //补充：这个方法执行了3次（具体原因不清楚）         在javac编译的时候回调该方法

        //4.2.获取APP中所有用到了BindView注解的对象
        Set<? extends Element> elementsAnnotatedWith = roundEnvironment.getElementsAnnotatedWith(BindView.class);

        //重复一下：不同类型Element其实就是映射了Java中不同的类元素
        //PackageElement          表示一个包程序元素。提供对有关包及其成员的信息的访问。
        //TypeElement 类           表示一个类或接口程序元素。提供对有关类型及其成员的信息的访问。注意，枚举类型是一种类，而注解类型是一种接口。
        //VariableElement 属性     表示一个字段、enum 常量、方法或构造方法参数、局部变量或异常参数。
        //ExecutableElement 方法   表示某个类或接口的方法、构造方法或初始化程序（静态或实例），包括注释类型元素。

        //4.3.开始对elementsAnnotatedWith进行分类

        //4.3.1.容器
        Map<String, List<VariableElement>> map = new HashMap<>();

        //4.3.2.扫描所有被@BindView注解的元素
        for (Element element : elementsAnnotatedWith) {
            //因为我们知道BindView元素的使用范围是在域上，所以这里我们进行了强制类型转换
            VariableElement variableElement = (VariableElement) element;
            String activityName = variableElement.getEnclosingElement().getSimpleName().toString();
            List<VariableElement> variableElements = map.get(activityName);
            if (variableElements == null) {
                variableElements = new ArrayList<>();
                map.put(activityName, variableElements);
            }
            variableElements.add(variableElement);
        }

        //4.3.3.开始生成文件

        //如：
        //package com.jack.a2021_09_06day01;
        //import com.jack.a2021_09_06day01.JBinder;
        //public class MainActivity_ViewBinding implements JBinder<com.jack.a2021_09_06day01.MainActivity> {
        //    @Override
        //    public void bind(com.jack.a2021_09_06day01.MainActivity target) {
        //        target.mTextView = (android.widget.TextView) target.findViewById(2131231003);
        //    }
        //}

        if (map.size() > 0) {
            Writer writer = null;
            Iterator<String> iterator = map.keySet().iterator();
            while (iterator.hasNext()) {
                String activityName = iterator.next();
                List<VariableElement> variableElements = map.get(activityName);

                //得到包名
                TypeElement enclosingElement = (TypeElement) variableElements.get(0).getEnclosingElement();
                String packageName = processingEnv.getElementUtils().getPackageOf(enclosingElement).toString();

                try {
                    JavaFileObject sourceFile = filer.createSourceFile(packageName + "." + activityName + "_ViewBinding");
                    writer = sourceFile.openWriter();

                    //        package com.jack.a2021_09_06day01;
                    writer.write("package " + packageName + ";\n");
                    //        import com.jack.a2021_09_06day01.JBinder;
                    writer.write("import " + packageName + ".JBinder;\n");
                    //        public class MainActivity_ViewBinding implements JBinder<com.jack.a2021_09_06day01.MainActivity> {
                    writer.write("public class " + activityName + "_ViewBinding implements JBinder<" +
                            packageName + "." + activityName + ">{\n");
                    //            @Override
                    //            public void bind(com.jack.a2021_09_06day01.MainActivity target) {
                    writer.write(" @Override\n" +
                            " public void bind(" + packageName + "." + activityName + " target){");
                    //target.mTextView = (android.widget.TextView) target.findViewById(2131231003);
                    for (VariableElement variableElement : variableElements) {
                        //得到名字
                        String variableName = variableElement.getSimpleName().toString();
                        //得到ID
                        int id = variableElement.getAnnotation(BindView.class).value();
                        //得到类型
                        TypeMirror typeMirror = variableElement.asType();
                        writer.write("target." + variableName + "=(" + typeMirror + ")target.findViewById(" + id + ");\n");
                    }

                    writer.write("\n}}");
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    if (writer != null) {
                        try {
                            writer.close();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }

        //4.1.返回值表示注解是否由当前Processor 处理
        return false;           //记录一下：这里测试true或false，没看到区别
    }

}